package EP.MetricasContenido;

import Controladores.ControladorOperaciones;
import EP.Web.Pagina;
import EP.Web.RelacionPaginas;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

/**
* @class TF
* @author Mauricio Alvarez.
* @brief Esta clase representa la clase TF, correspondiente a una entidad principal (EP).
*/
public class TF{

    /**
     *  @var int id_pagina
     *  @brief identificador de la página destino en la BD.
    */
    private int id_pagina;
    /**
     *  @var int id_relacion_pag
     *  @brief identificador de la tabla RELACION_PAGINA en la BD.
    */
    private int id_relacion_pag;
    /**
     *  @var int pag_id_pagina
     *  @brief identificador de una página origen en la BD.
    */
    private int pag_id_pagina;
    /**
     *  @var String Termino
     *  @brief Termino correspondiente a la consulta Q={q1,q2,...,qn}.
    */
    private String Termino;
    /**
     *  @var float Nij
     *  @brief Número de ocurrencias del termino i en la página j.
    */
    private double Nij = 0;
    /**
     *  @var float NTDj_SN
     *  @brief Numero de terminos de la Pagina (documento) dj (|Dj|). (SIN NORMALIZAR)
    */
    private double NTDj_SN = 0;
    /**
     *  @var float TFij_SN
     *  @brief Frecuencia del termino i en la pagina j. (SIN NORMALIZAR)
    */
    private double TFij_SN = 0;
    /**
     *  @var float NTDj_N
     *  @brief Frecuencia del termino i que más aparece en la página j (NORMALIZADO).
    */
    private double NTDj_N = 0;
    /**
     *  @var float TFij_N
     *  @brief Frecuencia del termino i en la pagina j (NORMALIZADO).
    */
    private double TFij_N = 0;
    /**
     *  @var float TFij_S
     *  @brief Frecuencia del termino i en la pagina j (SUAVISADO).
    */
    private double TFij_S = 0;
    /**
     *  @var private ControladorOperaciones cop
     *  @brief Variable global de tipo clase ControladorOperaciones.
    */
    private ControladorOperaciones cop;


    /////////////////
    // CONSTRUCTOR
    /////////////////
    public TF()
    {
        cop = new ControladorOperaciones();
    }


    //////////////////////////
    // Getter y Setter
    //////////////////////////
    public double getNTDj_N() {
        return NTDj_N;
    }

    public void setNTDj_N(double NTDj_N) {
        this.NTDj_N = NTDj_N;
    }

    public double getNTDj_SN() {
        return NTDj_SN;
    }

    public void setNTDj_SN(double NTDj_SN) {
        this.NTDj_SN = NTDj_SN;
    }

    public double getNij() {
        return Nij;
    }

    public void setNij(double Nij) {
        this.Nij = Nij;
    }

    public double getTFij_N() {
        return TFij_N;
    }

    public void setTFij_N(double TFij_N) {
        this.TFij_N = TFij_N;
    }

    public double getTFij_S() {
        return TFij_S;
    }

    public void setTFij_S(double TFij_S) {
        this.TFij_S = TFij_S;
    }

    public double getTFij_SN() {
        return TFij_SN;
    }

    public void setTFij_SN(double TFij_SN) {
        this.TFij_SN = TFij_SN;
    }

    public String getTermino() {
        return Termino;
    }

    public void setTermino(String Termino) {
        this.Termino = Termino;
    }

    public int getId_pagina() {
        return id_pagina;
    }

    public void setId_pagina(int id_pagina) {
        this.id_pagina = id_pagina;
    }

    public int getId_relacion_pag() {
        return id_relacion_pag;
    }

    public void setId_relacion_pag(int id_relacion_pag) {
        this.id_relacion_pag = id_relacion_pag;
    }

    public int getPag_id_pagina() {
        return pag_id_pagina;
    }

    public void setPag_id_pagina(int pag_id_pagina) {
        this.pag_id_pagina = pag_id_pagina;
    }


    //////////////////////////
    // OPERACIONES
    //////////////////////////

    /**
     * @brief Calcula el TF de todas las páginas que se encuentran dentro de la
     * base de datos para un termino que se entrega por entrada. Esta entrada puede
     * se cualquier consulta del usuario o palabras de la ontología.
     * @param Topico, Stopwords, ListaPaginas, ListaRelacionPaginas, TopicoConsultado, OpcionContenido, Umbral, Ranking
     * @return Map<Integer, ArrayList>
    */

    public Map<Integer, List> CalcularTF(Map<String, Integer> Topico,
                                         Map<String, Integer> Stopwords,
                                         List<Pagina> ListaPaginas,
                                         List<RelacionPaginas> ListaRelacionPaginas,
                                         String TopicoConsultado,
                                         int OpcionContenido,
                                         double Umbral,
                                         int Ranking) throws FileNotFoundException, IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, SQLException
    { 
        
        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        int id_pagina = 0;    //DESTINO
        int pag_id_pagina = 0;//ORIGEN
        int id_relacion_pag = 0;//ID de RELACION_PAGINAS
        double Nij = 0;
        double NTDj_SN = 0;
        double TFij_SN = 0;
        double NTDj_N = 0;
        double TFij_N = 0;
        double TFij_S = 0;
        String url;
        String contenido;
        String texto_alrededor;
        int es_semilla;
        int frecuenciaMax;
        TF tf;


        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {

            System.out.println("***************************************");
            System.out.println("**      CALCULO DE TF (BODY)         **");
            System.out.println("***************************************");

            //Guarda las páginas con los resultados TF:
            Map<Integer, List> TfPaginas = new HashMap();


            /////////////////////////////////////////////////////////////////////
            //PASO 1: Generar la lista invertida de los terminos de la página.
            /////////////////////////////////////////////////////////////////////
            for (int i = 0; i < ListaPaginas.size(); i++)
            {
                List<String> ContenidoPagina = new ArrayList();

                //Indice de terminos para la página:
                Map<String, Integer> IndiceTerminosPagina = new HashMap();
                //Diccionario de terminos para la página:
                Set<String> TerminosPagina = new HashSet();

                Pagina pagina = new Pagina();
                pagina = ListaPaginas.get(i);

                id_pagina = pagina.getId_pagina();
                url = pagina.getUrl();
                contenido = pagina.getContenido();
                es_semilla = pagina.getEs_semilla();

                String termino;

                //Se obtienen los terminos correspondientes del contenido de las
                //páginas:
                if (contenido == null)
                {
                    contenido = "null";
                }

                ContenidoPagina = cop.ObtenerPalabrasPagina(contenido, Stopwords);
                
                if (ContenidoPagina.isEmpty() == true)
                {
                    ContenidoPagina.add("null");
                }

                //Para cada termino se contabiliza las apariciones en el documento:
                for (int j = 0; j < ContenidoPagina.size(); j++)
                {

                    //Si NO se puede agregar al conjunto de terminos:
                    if(!TerminosPagina.add(ContenidoPagina.get(j)))
                    {
                        //Entonces el termino ya esta en el indice por lo que se
                        //aumenta su frecuencia en el documento:
                        termino = cop.FormatearConsulta(ContenidoPagina.get(j));
                        int frecuenciaT = IndiceTerminosPagina.get(termino);
                        IndiceTerminosPagina.put(termino, new Integer(frecuenciaT + 1));

                    }else{
                        //Si NO se ingresa el termino al indice, es porque no estaba
                        //con anterioridad, por lo que se ingresa al indice con
                        //frecuencia 1:
                        termino = cop.FormatearConsulta(ContenidoPagina.get(j));
                        IndiceTerminosPagina.put(termino, 1);

                    }

                }

                //Este conjunto ordena de forma creciente las frecuencias de terminos
                //para la página i:
                SortedSet<Integer> conjuntoFrecuenciasPagina = new TreeSet<Integer>();
                Set conjuntoIndice = IndiceTerminosPagina.entrySet();
                Iterator iter = conjuntoIndice.iterator();

                //Mientras existan elementos en el indice:
                while(iter.hasNext())
                {
                  //Extraer las frecuencias para su orden.
                  Map.Entry me = (Map.Entry)iter.next();
                  conjuntoFrecuenciasPagina.add((Integer)me.getValue());
                }

                //Se extrae la cola del conjunto correspondiente a la frecuencia
                //mayor:
                frecuenciaMax = conjuntoFrecuenciasPagina.last();


                // BORRAR ESTO DESPUES!! //////////////////////////////////////////////////////////////////////////////

                  System.out.println("++++++++++++++++++++++++++++++++++++");
                  System.out.println("id_pagina: "+ id_pagina);
                  System.out.println("url: "+ url);
                  System.out.println("para la pagina la mayor frecuencia es: "+ conjuntoFrecuenciasPagina.last());
                  System.out.println("Largo de la pagina: "+ IndiceTerminosPagina.size());

                  Set set1 = IndiceTerminosPagina.entrySet();
                  Iterator iter1 = set1.iterator();

                  while(iter1.hasNext())
                  {
                      Map.Entry me1 = (Map.Entry)iter1.next();
                      if ((Integer)me1.getValue() == (Integer) conjuntoFrecuenciasPagina.last())
                      {
                          System.out.println("termino con mas frecuencia: "+ me1.getKey().toString());
                      }
                      //System.out.println("PAR: "+ me1.getKey().toString() + " - "+ me1.getValue());

                  }



                // BORRAR ESTO DESPUES!! ////////////////////////////////////////////////////////////////////////////


                /////////////////////////////////////////////////////////
                //PASO 2: Para cada termino del topico o consulta hacer:
                /////////////////////////////////////////////////////////
                Set conjuntoTopico = Topico.entrySet();
                Iterator it = conjuntoTopico.iterator();

                //Guarda los resultados TF para cada página:
                ArrayList<TF> ResultadosTF = new ArrayList<TF>();

                while(it.hasNext())
                {

                    Map.Entry par = (Map.Entry)it.next();
                    //Se obtiene el primer termino del tópico:(consulta)
                    termino = cop.FormatearConsulta(par.getKey().toString());

                    //Si el termino del topico se encuentra dentro del indice:
                    if (IndiceTerminosPagina.containsKey(termino))
                    {
                        ////////////////////////////
                        // (1) TF Sin Normalizar
                        ////////////////////////////
                        //   TFij_SN = Nij_SN / NTDj_SN
                        //
                        //Nij : Número de ocurrencias del termino i en la página j.
                        //NTDj_SN: Numero de terminos de la Pagina (documento) dj (|Dj|)
                        //TFij_SN: Frecuencia del termino i en la pagina j.

                        //Se obtiene la frecuencia del termino del indice:
                        Nij = Double.valueOf(IndiceTerminosPagina.get(par.getKey().toString()));

                        //Se obtiene el numero de terminos de la página:
                        NTDj_SN = ContenidoPagina.size();

                        //Se calcula el TF del termino i en la página j:
                        TFij_SN = Nij / NTDj_SN;

                        ////////////////////////////
                        // (2) TF Normalizado
                        ////////////////////////////
                        //   TFij_SN = Nij_SN / NTDj_SN
                        //
                        //Nij : Número de ocurrencias del termino i en la página j.
                        //NTDj_N: Frecuencia del termino i que más aparece en la página j.
                        //TFij_N: Frecuencia del termino i en la pagina j.

                        //Se obtiene la frecuencia del termino i más frecuente de la
                        //página desde el conjunto ordenado:
                        NTDj_N = conjuntoFrecuenciasPagina.last();

                        //Se calcula el TF Normalizado:
                        TFij_N = Nij / NTDj_N;

                        ////////////////////////////
                        // (3) TF Suavisado
                        ////////////////////////////
                        //   TFij_SN = 1 + log(Nij)
                        //
                        //Nij : Número de ocurrencias del termino i en la página j.
                        //TFij_S: Frecuencia del termino i en la pagina j.

                        //Se calcula el TF suavisado:
                        TFij_S = 1 + Math.log10(Nij);


                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                        System.out.println("------------------------------------");
                        System.out.println("id_pagina...:( "+ id_pagina);
                        System.out.println("termino...:( "+ termino);
                        System.out.println("Nij: "+ Nij);
                        System.out.println("NTDj_SN: "+ NTDj_SN);
                        System.out.println("NTDj_N: "+ NTDj_N);
                        System.out.println("TFij_SN: "+ TFij_SN);
                        System.out.println("TFij_N: "+ TFij_N);
                        System.out.println("TFij_S: "+ TFij_S);

                        System.out.println("++++++++++++++++++++++++++++++++++++");

                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                        //Guardar en un ArrayList<TF> los resultados del TF de cada
                        //termino de la página:
                        tf = new TF();
                        tf.setId_pagina(id_pagina);
                        tf.setTermino(termino);
                        tf.setNij(Nij);
                        tf.setNTDj_SN(NTDj_SN);
                        tf.setNTDj_N(NTDj_N);
                        tf.setTFij_SN(TFij_SN);
                        tf.setTFij_N(TFij_N);
                        tf.setTFij_S(TFij_S);

                        ResultadosTF.add(tf);

                        //Se resetan las variables TF:
                        Nij = 0;
                        NTDj_SN = 0;
                        TFij_SN = 0;
                        NTDj_N = 0;
                        TFij_N = 0;
                        TFij_S = 0;

                    }else{
                        //Si el termino del tópico NO se encuentra en el indice, se
                        //almacena en el Map con valores ceros para el termino en la
                        //página:

                        //Se obtiene el numero de terminos de la página:
                        NTDj_SN = ContenidoPagina.size();

                        //Se obtiene la frecuencia del termino i más frecuente de la
                        //página desde el conjunto ordenado:
                        NTDj_N = conjuntoFrecuenciasPagina.last();

                        tf = new TF();
                        tf.setId_pagina(id_pagina);
                        tf.setTermino(termino);
                        tf.setNij(0);
                        tf.setNTDj_SN(NTDj_SN);
                        tf.setNTDj_N(NTDj_N);
                        tf.setTFij_SN(0);
                        tf.setTFij_N(0);
                        tf.setTFij_S(0);

                        ResultadosTF.add(tf);

                        //Se resetan las variables TF:
                        Nij = 0;
                        NTDj_SN = 0;
                        TFij_SN = 0;
                        NTDj_N = 0;
                        TFij_N = 0;
                        TFij_S = 0;

                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                        System.out.println("------------------------------------");
                        System.out.println("id_pagina...:( "+ id_pagina);
                        System.out.println("termino...:( "+ termino);
                        System.out.println("Nij: "+ Nij);
                        System.out.println("NTDj_SN: "+ NTDj_SN);
                        System.out.println("NTDj_N: "+ NTDj_N);
                        System.out.println("TFij_SN: "+ TFij_SN);
                        System.out.println("TFij_N: "+ TFij_N);
                        System.out.println("TFij_S: "+ TFij_S);

                        System.out.println("++++++++++++++++++++++++++++++++++++");

                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                    }//FIN if busqueda indice

                }//FIN while Topico

                /////////////////////////////////////////////////////////////////
                //PASO 3: Se guardan los puntajes TF de la página en el HashMap
                /////////////////////////////////////////////////////////////////
                TfPaginas.put(id_pagina, ResultadosTF);


            }//for paginas

            return TfPaginas;

        }//FIN IF BODY


        
        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            System.out.println("***************************************");
            System.out.println("**   CALCULO DE TF (SURROUND TEXT)   **");
            System.out.println("***************************************");

            //Guarda los ST de las páginas con los resultados TF:
            Map<Integer, List> TfRelacionPaginas = new HashMap();


            /////////////////////////////////////////////////////////////////////
            //PASO 1: Generar la lista invertida de los terminos de la página.
            /////////////////////////////////////////////////////////////////////
            for (int i = 0; i < ListaRelacionPaginas.size(); i++)
            {

                //Almacena el surround text de la página origen:
                List<String> ContenidoST = new ArrayList();

                //Indice de terminos para surround text:
                Map<String, Integer> IndiceTerminosST = new HashMap();

                //Diccionario de terminos para surround text de la página:
                Set<String> TerminosST = new HashSet();

                //Se obtienen los registros de cada fila de la tabla
                //RELACION_PAGINA:
                
                RelacionPaginas rp = new RelacionPaginas();
                rp = ListaRelacionPaginas.get(i);
                
                //Se extraen los atributos del registro:
                id_relacion_pag = rp.getId_relacion_pagina();
                id_pagina = rp.getId_pagina_destino();
                pag_id_pagina = rp.getId_pagina_fuente();
                texto_alrededor = rp.getTexto_alrededor();


                //Del contenido del surround text se extraen los Stopwords:
                if (texto_alrededor == null)
                {
                    texto_alrededor = "null";
                }

                ContenidoST = cop.ObtenerPalabrasPagina(texto_alrededor, Stopwords);

                if (ContenidoST.isEmpty() == true)
                {
                    ContenidoST.add("null");
                }

                //Para cada termino se contabiliza las apariciones en el documento:
                String termino;

                for (int j = 0; j < ContenidoST.size(); j++)
                {
                    
                    //Si NO se puede agregar al conjunto de terminos:
                    if(!TerminosST.add(ContenidoST.get(j)))
                    {
                        //Entonces el termino ya esta en el indice por lo que se
                        //aumenta su frecuencia en el documento:
                        termino = cop.FormatearConsulta(ContenidoST.get(j));
                        int frecuenciaT = IndiceTerminosST.get(termino);
                        IndiceTerminosST.put(termino, new Integer(frecuenciaT + 1));

                    }else{
                        //Si NO se ingresa el termino al indice, es porque no estaba
                        //con anterioridad, por lo que se ingresa al indice con
                        //frecuencia 1:
                        termino = cop.FormatearConsulta(ContenidoST.get(j));
                        IndiceTerminosST.put(termino, 1);

                    }

                }//FIN for ContenidoST

                

                //Este conjunto ordena de forma creciente las frecuencias de terminos
                //para la página i:
                SortedSet<Integer> conjuntoFrecuenciasST = new TreeSet<Integer>();
                Set conjuntoIndice = IndiceTerminosST.entrySet();
                Iterator iter = conjuntoIndice.iterator();

                //Mientras existan elementos en el indice:
                while(iter.hasNext())
                {
                  //Extraer las frecuencias para su orden.
                  Map.Entry me = (Map.Entry)iter.next();
                  conjuntoFrecuenciasST.add((Integer)me.getValue());
                }

                //Se extrae la cola del conjunto correspondiente a la frecuencia
                //mayor:
                frecuenciaMax = conjuntoFrecuenciasST.last();


                // BORRAR ESTO DESPUES!! //////////////////////////////////////////////////////////////////////////////

                  System.out.println("++++++++++++++++++++++++++++++++++++");
                  System.out.println("id_relacion_pag: "+ id_relacion_pag);
                  System.out.println("id_pagina: "+ id_pagina);
                  System.out.println("texto_alrededor: "+ texto_alrededor);
                  System.out.println("para la pagina la mayor frecuencia es: "+ conjuntoFrecuenciasST.last());
                  System.out.println("Largo de la pagina: "+ IndiceTerminosST.size());

                  Set set1 = IndiceTerminosST.entrySet();
                  Iterator iter1 = set1.iterator();

                  while(iter1.hasNext())
                  {
                      Map.Entry me1 = (Map.Entry)iter1.next();
                      if ((Integer)me1.getValue() == (Integer) conjuntoFrecuenciasST.last())
                      {
                          System.out.println("termino con mas frecuencia: "+ me1.getKey().toString());
                      }
                      //System.out.println("PAR: "+ me1.getKey().toString() + " - "+ me1.getValue());

                  }



                // BORRAR ESTO DESPUES!! ////////////////////////////////////////////////////////////////////////////


                /////////////////////////////////////////////////////////
                //PASO 2: Para cada termino del topico o consulta hacer:
                /////////////////////////////////////////////////////////
                Set conjuntoTopico = Topico.entrySet();
                Iterator it = conjuntoTopico.iterator();

                //Guarda los resultados TF para cada página:
                ArrayList<TF> ResultadosTF = new ArrayList<TF>();

                while(it.hasNext())
                {

                    Map.Entry par = (Map.Entry)it.next();
                    //Se obtiene el primer termino del tópico:(consulta)
                    termino = cop.FormatearConsulta(par.getKey().toString());

                    //Si el termino del topico se encuentra dentro del indice:
                    if (IndiceTerminosST.containsKey(termino))
                    {
                        System.out.println("SI ME ENCUENTRO EN EL INDICE...");

                        ////////////////////////////
                        // (1) TF Sin Normalizar
                        ////////////////////////////
                        //   TFij_SN = Nij_SN / NTDj_SN
                        //
                        //Nij : Número de ocurrencias del termino i en la página j.
                        //NTDj_SN: Numero de terminos de la Pagina (documento) dj (|Dj|)
                        //TFij_SN: Frecuencia del termino i en la pagina j.

                        //Se obtiene la frecuencia del termino del indice:
                        Nij = Double.valueOf(IndiceTerminosST.get(par.getKey().toString()));

                        //Se obtiene el numero de terminos del surround text:
                        NTDj_SN = ContenidoST.size();

                        //Se calcula el TF del termino i en la página j:
                        TFij_SN = Nij / NTDj_SN;

                        ////////////////////////////
                        // (2) TF Normalizado
                        ////////////////////////////
                        //   TFij_SN = Nij_SN / NTDj_SN
                        //
                        //Nij : Número de ocurrencias del termino i en la página j.
                        //NTDj_N: Frecuencia del termino i que más aparece en la página j.
                        //TFij_N: Frecuencia del termino i en la pagina j.

                        //Se obtiene la frecuencia del termino i más frecuente de la
                        //página desde el conjunto ordenado:
                        NTDj_N = conjuntoFrecuenciasST.last();

                        //Se calcula el TF Normalizado:
                        TFij_N = Nij / NTDj_N;

                        ////////////////////////////
                        // (3) TF Suavisado
                        ////////////////////////////
                        //   TFij_SN = 1 + log(Nij)
                        //
                        //Nij : Número de ocurrencias del termino i en la página j.
                        //TFij_S: Frecuencia del termino i en la pagina j.

                        //Se calcula el TF suavisado:
                        TFij_S = 1 + Math.log10(Nij);


                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                        System.out.println("------------------------------------");
                        System.out.println("id_pagina...: "+ id_pagina);
                        System.out.println("id_relacion_pag...: "+ id_relacion_pag);
                        System.out.println("termino...: "+ termino);
                        System.out.println("Nij: "+ Nij);
                        System.out.println("NTDj_SN: "+ NTDj_SN);
                        System.out.println("NTDj_N: "+ NTDj_N);
                        System.out.println("TFij_SN: "+ TFij_SN);
                        System.out.println("TFij_N: "+ TFij_N);
                        System.out.println("TFij_S: "+ TFij_S);

                        System.out.println("++++++++++++++++++++++++++++++++++++");

                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                        //Guardar en un ArrayList<TF> los resultados del TF de cada
                        //termino de la página:
                        tf = new TF();
                        tf.setId_pagina(id_pagina);
                        tf.setId_relacion_pag(id_relacion_pag);
                        tf.setPag_id_pagina(pag_id_pagina);
                        tf.setTermino(termino);
                        tf.setNij(Nij);
                        tf.setNTDj_SN(NTDj_SN);
                        tf.setNTDj_N(NTDj_N);
                        tf.setTFij_SN(TFij_SN);
                        tf.setTFij_N(TFij_N);
                        tf.setTFij_S(TFij_S);

                        ResultadosTF.add(tf);

                        //Se resetan las variables TF:
                        Nij = 0;
                        NTDj_SN = 0;
                        TFij_SN = 0;
                        NTDj_N = 0;
                        TFij_N = 0;
                        TFij_S = 0;


                    }else{
                        //Si el termino del tópico NO se encuentra en el indice, se
                        //almacena en el Map con valores ceros para el termino en la
                        //página:

                        System.out.println("NO ME ENCUENTRO EN EL INDICE...");

                        //Se obtiene el numero de terminos de la página:
                        NTDj_SN = ContenidoST.size();

                        //Se obtiene la frecuencia del termino i más frecuente del
                        //surrounf text desde el conjunto ordenado:
                        NTDj_N = conjuntoFrecuenciasST.last();

                        tf = new TF();
                        tf.setId_pagina(id_pagina);
                        tf.setId_relacion_pag(id_relacion_pag);
                        tf.setPag_id_pagina(pag_id_pagina);
                        tf.setTermino(termino);
                        tf.setNij(0);
                        tf.setNTDj_SN(NTDj_SN);
                        tf.setNTDj_N(NTDj_N);
                        tf.setTFij_SN(0);
                        tf.setTFij_N(0);
                        tf.setTFij_S(0);

                        ResultadosTF.add(tf);


                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                        System.out.println("------------------------------------");
                        System.out.println("id_pagina...:( "+ id_pagina);
                        System.out.println("termino...:( "+ termino);
                        System.out.println("Nij: "+ Nij);
                        System.out.println("NTDj_SN: "+ NTDj_SN);
                        System.out.println("NTDj_N: "+ NTDj_N);
                        System.out.println("TFij_SN: "+ TFij_SN);
                        System.out.println("TFij_N: "+ TFij_N);
                        System.out.println("TFij_S: "+ TFij_S);

                        System.out.println("++++++++++++++++++++++++++++++++++++");

                        //BORRAR ESTOOOOO!!!:!::!:!:!:!:!:!:!:!:!:!:!!:::!:!::!:!:!

                        //Se resetan las variables TF:
                        Nij = 0;
                        NTDj_SN = 0;
                        TFij_SN = 0;
                        NTDj_N = 0;
                        TFij_N = 0;
                        TFij_S = 0;

                        
                    }//FIN if busqueda indice

                }//FIN while Topico

                /////////////////////////////////////////////////////////////////
                //PASO 3: Se guardan los puntajes TF de la página en el HashMap
                /////////////////////////////////////////////////////////////////
                TfRelacionPaginas.put(id_relacion_pag, ResultadosTF);


            }//FIN for ListaRelacionPaginas

            return TfRelacionPaginas;

        }//FIN IF SURROUND TEXT

        return null;
        
    }//FIN CalcularTF (OK)

}//FIN CLASE TF